home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / HDX_BACK / HDX500 / FMT.C < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-09  |  9.3 KB  |  439 lines
  1. /* fmt.c */
  2.  
  3. #include "obdefs.h"
  4. #include "osbind.h"
  5. #include "mydefs.h"
  6. #include "part.h"
  7. #include "hdx.h"
  8. #include "addr.h"
  9. #include "error.h"
  10.  
  11. #define MFM 17            /* sectors per track of MFM */
  12. #define RLL 26            /* sectors per track of RLL */
  13.  
  14. extern long ostack;
  15. extern int typedev;
  16. extern int typedrv;
  17. extern char sbuf[];
  18.  
  19. /*
  20.  * These constants are used in a heuristic that determines
  21.  * if the format parameter information in the boot sector
  22.  * is intact.  (See fmtpok()).
  23.  */
  24. #define    MAXCYLS        4096        /* max number of cylinders */
  25. #define    MINCYLS        100        /* minimum number of cylinders */
  26. #define    MAXHEADS    16        /* max number of heads */
  27. #define    MINHEADS    2        /* minimum number of heads */
  28. #define    MAXLZ        16        /* max landing zone value */
  29. #define    MAXRT        2        /* max step-rate code */
  30.  
  31.  
  32. /*
  33.  * These are the default format parameters;
  34.  * they are for a 20Mb Mutsubuishi drive.
  35.  *
  36.  * @ If we change drives, this might have to be changed.
  37.  *
  38.  */
  39. HINFO deffmt = {
  40.     0x264,        /* 612 cylinders */
  41.     4,            /* 4 heads */
  42.     0x264,        /* no reduced write-current cylinder */
  43.     0x264,        /* no write precomp cylinder */
  44.     10,            /* landing zone position = 10 */
  45.     2,            /* 2 use buffered seeks */
  46.     1,            /* 2 interleave = 1 */
  47.     17            /* 17 sectors per track */
  48. };
  49.  
  50.  
  51. /*
  52.  * Report format error.
  53.  *
  54.  */
  55. formaterr(dev)
  56. int dev;
  57. {
  58.     char *pdev="X";
  59.     
  60.     if (dev > 15)
  61.         dev -= 16;
  62.     else if (dev > 7) 
  63.         dev -= 8;
  64.     *pdev = dev + '0';
  65.     (cantform[FMTDEV].ob_spec)->te_ptext = pdev;
  66.     cantform[FMTERROK].ob_state = NORMAL;
  67.     execform(cantform);
  68.     return ERROR;
  69. }
  70.  
  71.  
  72. /*
  73.  * Set format parameters in a
  74.  * root sector image.
  75.  * 6-13-88  only set size of hard disk.
  76.  *
  77.  */
  78.  
  79. sdisksiz(image, hdsiz)
  80. char *image;
  81. long hdsiz;
  82. {
  83.     ((RSECT *)(image + 0x200 - sizeof(RSECT)))->hd_siz = hdsiz;
  84.  
  85. }
  86.  
  87.  
  88. /*
  89.  * Set format parameters in a
  90.  * root sector image.
  91.  *
  92.  */
  93. sfmtparm(image, fmtparm)
  94. char *image;
  95. HINFO *fmtparm;
  96. {
  97.     register HINFO *rinfo;
  98.     register long siz;
  99.  
  100.     rinfo = &((RSECT *)(image + 0x200 - sizeof(RSECT)))->hd_info;
  101.     rinfo->hi_cc = fmtparm->hi_cc;
  102.     rinfo->hi_dhc = fmtparm->hi_dhc;
  103.     rinfo->hi_rwcc = fmtparm->hi_rwcc;
  104.     rinfo->hi_wpc = fmtparm->hi_wpc;
  105.     rinfo->hi_lz = fmtparm->hi_lz;
  106.     rinfo->hi_rt = fmtparm->hi_rt;
  107.     rinfo->hi_in = fmtparm->hi_in;
  108.     rinfo->hi_spt = fmtparm->hi_spt;
  109.  
  110.     /* Compute total disk size
  111.      * = <#cyls> * <#heads> * <#sectors / track>
  112.      */
  113.     ((RSECT *)(image + 0x200 - sizeof(RSECT)))->hd_siz = 
  114.         (long)fmtparm->hi_cc *
  115.         (long)fmtparm->hi_dhc *
  116.         (long)fmtparm->hi_spt; 
  117.  
  118. }
  119.  
  120.  
  121. /*
  122.  * Determine if format parameters are good;
  123.  * return OK if they appear to be,
  124.  * ERROR if they don't appear to be.
  125.  *
  126.  */
  127. fmtpok(fmtparm)
  128. HINFO *fmtparm;
  129. {
  130.     if (fmtparm->hi_cc > MAXCYLS ||
  131.     fmtparm->hi_cc < MINCYLS ||
  132.     fmtparm->hi_dhc > MAXHEADS ||
  133.     fmtparm->hi_dhc < MINHEADS ||
  134.     fmtparm->hi_lz > MAXLZ ||
  135.     fmtparm->hi_rt > MAXRT)
  136.         return ERROR;
  137.  
  138.     return OK;
  139. }
  140.  
  141.  
  142. /*
  143.  * Setup default format parameters in hinfo;
  144.  * (REAL C compilers do this with a structure assignment...)
  145.  *
  146.  */
  147. fdefault(hinfop)
  148. HINFO *hinfop;
  149. {
  150.     hinfop->hi_cc = deffmt.hi_cc;
  151.     hinfop->hi_dhc = deffmt.hi_dhc;
  152.     hinfop->hi_rwcc = deffmt.hi_rwcc;
  153.     hinfop->hi_wpc = deffmt.hi_wpc;
  154.     hinfop->hi_lz = deffmt.hi_lz;
  155.     hinfop->hi_rt = deffmt.hi_rt;
  156.     hinfop->hi_in = deffmt.hi_in;
  157.     hinfop->hi_spt = deffmt.hi_spt;
  158. }
  159.  
  160.  
  161. /*
  162.  * Set mode information on drive.
  163.  *
  164.  */
  165. ms(dev, hinfo)
  166. int dev;
  167. HINFO *hinfo;
  168. {
  169.     int i;
  170.     char *p;
  171.     SETMODE mb;
  172.     extern long mdselect();
  173.  
  174.     /* initialize parameter structure */
  175.     p = (char *)&mb;
  176.     for (i = sizeof(SETMODE); i--;)
  177.     *p++ = 0;
  178.     mb.smd_8 = 0x08;
  179.     mb.smd_1 = 0x01;
  180.     mb.smd_bs[1] = 0x02;    /* block size = 512 */
  181.  
  182.     cpw(&mb.smd_cc[0], hinfo->hi_cc);
  183.     mb.smd_dhc = hinfo->hi_dhc;
  184.     cpw(&mb.smd_rwc[0], hinfo->hi_rwcc);
  185.     cpw(&mb.smd_wpc[0], hinfo->hi_wpc);
  186.     mb.smd_lz = hinfo->hi_lz;
  187.     mb.smd_rt = hinfo->hi_rt;
  188.  
  189.     return (int)mdselect(dev, 22, &mb);
  190. }
  191.  
  192.  
  193. /*
  194.  * Move `w' to unaligned location.
  195.  *
  196.  */
  197. cpw(d, w)
  198. char *d;
  199. WORD w;
  200. {
  201.     char *s;
  202.  
  203.     s = (char *)&w;
  204.     d[0] = s[0];
  205.     d[1] = s[1];
  206. }
  207.  
  208.  
  209. /*
  210.  * Return format parameters in `hinfo', based on
  211.  * the format parameter name `fpnam'.
  212.  *
  213.  * return 0 on OK,
  214.  * -1 on [CANCEL].
  215.  *
  216.  */
  217. gfparm(dev, noinfo, modesel, hinfop, fpnam, id)
  218. int dev;
  219. int *noinfo;            /* 1: no information inside the wincap file */
  220. int *modesel;
  221. HINFO *hinfop;
  222. char *fpnam, *id;
  223. {
  224.     long num;
  225.     char name[128];
  226.     int mask=0x0001;
  227.     int scsidrv, set, ret = OK;
  228.     UWORD cyl; 
  229.     BYTE nhead, sptrk;
  230.  
  231.     set = typedev & (mask << dev);
  232.     scsidrv = typedrv & (mask << dev);
  233.     fdefault(hinfop);
  234.      if (*noinfo)    {
  235.         if ((set) || (scsidrv) || (dev > 15))        {
  236.             *modesel = 0;
  237.             return (ret);
  238.         }
  239.         ret = cyhdsp(dev, &cyl, &nhead, &sptrk);
  240.         hinfop->hi_cc = cyl;
  241.         hinfop->hi_dhc = nhead;
  242.         hinfop->hi_rwcc = cyl;
  243.         hinfop->hi_wpc =  cyl;
  244.         hinfop->hi_spt =  sptrk;
  245.     } else {
  246.  
  247.         strcpy(name, fpnam);
  248.         if (wgetent(fpnam, id) == ERROR) {
  249.             nofmt[NOSCHFOK].ob_state = NORMAL;
  250.             (nofmt[NOSCHFMT].ob_spec)->te_ptext = name;
  251.             execform(nofmt);
  252.             return ERROR;
  253.         }
  254.         if ((set) || (scsidrv) || (dev > 15))        {
  255.             hinfop->hi_cc = 0;
  256.             hinfop->hi_dhc = 0;
  257.             hinfop->hi_spt =  0;
  258.         }
  259.         if (wgetnum("cy", &num) == OK) hinfop->hi_cc = (UWORD)num;
  260.         if (wgetnum("hd", &num) == OK) hinfop->hi_dhc = (BYTE)num;
  261.         if (wgetnum("rw", &num) == OK) hinfop->hi_rwcc = (UWORD)num;
  262.         if (wgetnum("wp", &num) == OK) hinfop->hi_wpc = (UWORD)num;
  263.         if (wgetnum("lz", &num) == OK) hinfop->hi_lz = (BYTE)num;
  264.         if (wgetnum("rt", &num) == OK) hinfop->hi_rt = (BYTE)num;
  265.         if (wgetnum("in", &num) == OK) hinfop->hi_in = (BYTE)num;
  266.         if (wgetnum("sp", &num) == OK) hinfop->hi_spt = (BYTE)num;
  267.         if (wgetnum("md", &num) == OK) *modesel = (UWORD)num;
  268.         if ((set) || (scsidrv) || (dev > 15))        
  269.             if((!hinfop->hi_cc)||(!hinfop->hi_dhc)||(!hinfop->hi_spt))    {
  270.                 *noinfo = 1;
  271.                 *modesel = 0;
  272.             }
  273.     }
  274.     return(ret);
  275. }
  276.  
  277.  
  278. /*
  279.  *    Set mode information on a SYQUEST drive.
  280.  *
  281.  */
  282.  
  283. sqms(dev, sendata)
  284. int dev;            /* physical device number */
  285. char sendata[];
  286. {
  287.     extern long mdselect();
  288.     char buf[32];
  289.  
  290.     inquiry(dev, (WORD)16, buf);
  291.     if (buf[8] == 'Q' & buf[9] == 'U' & buf[10] == 'A' & buf[11] == 'N') 
  292.         /* It is a QUANTUM hard disk. So don't need to set the page one. */
  293.         return OK;
  294.     sendata[0] = sendata[2] = 0;    /* reserved */
  295.     sendata[3] = 0x08;                /* block descriptor length */
  296.     sendata[12] = 0;                /* Reserved = 0; Page Code = 0 */
  297.     sendata[13] = 0x02;                
  298.     sendata[14] = 0x10;                /* set inhst bit in page 00 */
  299.     sendata[15] = 0;                /* Device type qualifier  */
  300.     return (int)mdselect(dev, 16, sendata);
  301. }
  302.  
  303.  
  304.  
  305.  
  306. /* 
  307.  * get cylinder, # of head, and sector per track for ST
  308.  */
  309.  
  310. cyhdsp(dev, cyl, head, spt)
  311.  
  312. int dev;
  313. UWORD *cyl; 
  314. BYTE *head, *spt;
  315.  
  316. {
  317.     char *num;
  318.     BYTE sptrk,numhead;
  319.     int i, ret, totcyl, numtrack;
  320.     extern long get3bytes();
  321.     SETMODE *mb;
  322.     SECTOR size, msiz;    /* size of media */
  323.     char buf[512], sendata[32];
  324.     long dmaptr, tmpptr, spcyl;
  325.     char *dmahigh=0xffff8609,
  326.          *dmamid=0xffff860b,
  327.          *dmalow=0xffff860d;
  328.  
  329.     /*
  330.     ostack = Super(NULL);
  331.     delay();
  332.     for (i = 0; i < 32; i++)
  333.         sendata[i] = 0;
  334.     if (mdsense(dev, 3, 0, 32, sendata) == OK)    {
  335.         for (i=0; i<32; i++)    {
  336.             if (sendata[i])
  337.                 break;
  338.         }
  339.         if (i == 32)    {     no info return in the buf 'sendata' 
  340.             goto dopg0;
  341.         }
  342.         if (!(*spt = getword(sendata+22)))    
  343.             goto dopg0;
  344.         if (mdsense(dev, 4, 0, 22, sendata) == OK)    {
  345.             for (i=0; i<22; i++)    {
  346.                 if (sendata[i])
  347.                     break;
  348.             }
  349.             if (i == 22)    {    no info return in the buf 'sendata' 
  350.                 goto dopg0;
  351.             }
  352.             if (!(*cyl = get3bytes(sendata+14)))
  353.                 goto dopg0;
  354.             if (!(*head = *(sendata+17)))
  355.                 goto dopg0;
  356.             delay();
  357.             Super(ostack);
  358.             return OK;
  359.         } 
  360.     } 
  361.  
  362. dopg0:
  363. */
  364.     ostack = Super(NULL);
  365.     delay();
  366.     for (i = 0; i < 22; i++)
  367.         sendata[i] = 0;
  368.     /* get format parameters/ disk size from emdia */
  369.     ret = mdsense(dev, 0, 0, 22, sendata);
  370.     delay();
  371.     Super(ostack);
  372.     if (ret != OK)     {
  373.         return ERROR;
  374.     }
  375.     for (i=0; i<22; i++)    {
  376.         if (sendata[i])
  377.             break;
  378.     }
  379.     if (i == 22)    {    /* no info return in the buf 'sendata' */
  380.         err(needinfo);
  381.         return ERROR;
  382.     }
  383.  
  384.       mb = (SETMODE *)sendata;
  385.     /* get number of cylinders */
  386.     totcyl = mb->smd_cc[0];
  387.     totcyl <<= 8;
  388.     totcyl |= mb->smd_cc[1];
  389.     *cyl = (UWORD)totcyl;
  390.  
  391.     /* get number of heads */
  392.     numhead = mb->smd_dhc;
  393.     *head = numhead;
  394.   
  395.     sptrk = (long)MFM;
  396.     msiz = (SECTOR)numhead * (SECTOR)totcyl * sptrk;
  397.   
  398.     for (i = 0; i < 20; i++) {
  399.         if ((ret = rdsects(dev, 1, buf, msiz+i)) == OK) {
  400.  
  401.         /* find out whether data has been transferred, by
  402.               checking if dma pointer has been moved.      */
  403.  
  404.             ostack = Super(NULL);
  405.             delay();
  406.             dmaptr = *dmahigh;
  407.             dmaptr &= 0x0000003f;
  408.             dmaptr <<= 16;
  409.             tmpptr = *dmamid;
  410.             tmpptr &= 0x000000ff;
  411.             tmpptr <<= 8;
  412.             dmaptr |= tmpptr;
  413.             tmpptr = *dmalow;
  414.             tmpptr &= 0x000000ff;
  415.             dmaptr |= tmpptr;
  416.             delay();
  417.             Super(ostack);
  418.  
  419.             if (dmaptr != buf)
  420.                 break;
  421.            } else {            /* rdsects return an error */
  422.             if (tsterr(ret) == OK) {
  423.                     break;
  424.             }
  425.            }
  426.     }
  427.  
  428.     /* Determine if media is MFM or RLL */
  429.     if (i < 20)        {
  430.         *spt = RLL;
  431.     } else {
  432.         *spt = MFM;
  433.     }
  434.     return OK;
  435. }
  436.  
  437.  
  438.  
  439.